#!/usr/bin/python

#importo la red
import red
reload(red)
red = red.red


#importo las posiciones para verlo dibujado
import posiciones3millones
pos = posiciones3millones.pos

#modulo de grafos
import networkx as nx
import matplotlib.pyplot as plt

#creo el multigrafo
G=nx.MultiDiGraph()
autores = red.keys()

#importo el diccionario nombres-id
import nombresId_dic
reload(nombresId_dic)
nombres = nombresId_dic.nombres


#armo el inverso de nombres
ids={}
for au in nombres:
	ids[ nombres[au] ] = au


for autor1 in autores:
	for autor2 in red[autor1].keys():
		dic = red[autor1]
		if autor2 in nombres.keys():
			 if dic[autor2]> 0:
				peso = 1/ float((dic[autor2]*10))
				G.add_edge(nombres[autor1],nombres[autor2], weight= peso )

elarge=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] >0.5]
esmall=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] <=0.5]

# nodes
nx.draw_networkx_nodes(G,pos,node_size=70)

# edges
nx.draw_networkx_edges(G,pos,edgelist=elarge, width=6)
nx.draw_networkx_edges(G,pos,edgelist=esmall,  width=0.5,alpha=0.5,edge_color='b',style='dashed')
                    

#calculo distancias
distancias =  nx.algorithms.shortest_paths.generic.shortest_path_length(G, weight=True)                    



#archivo=open("matrizDistancia.txt",'w')



#matrizDistancia = []
#for i in range(0,len(autores)):
	#vector=[]
	#for j in range(0,len(autores)):
		#if j in distancias[i].keys():
			#vector.append(distancias[i][j])
		#else: 
			#vector.append(-1)
	#matrizDistancia.append(vector)
	
	
##arreglo la diagonal
#for i in range(0,len(autores)):
	
	#if ids[i] in red[ids[i]].keys():
		##si en la red se relaciona con si mismo 
		#matrizDistancia[i][i]= 	1/float(red[ids[i]][ids[i]]*10)
	#else:
		#matrizDistancia[i][i]=-1
#archivo.write(str(matrizDistancia))
		
#print list(nx.algorithms.clique.find_cliques(G))
def salida(nodo):
	return filter(lambda e: e[1]==nodo,G.edges())

def esConexo(nodo):
	return (filter(lambda e: (e[1]==nodo and e[0]!=nodo) or (e[0]==nodo and e[1]!=nodo) ,G.edges()))
	
	
#print map(lambda x:ids[x], filter(lambda e: len(esConexo(e))<1, range(0,174)))

#clique de a 3
#for a1 in range(0,174):
#	for a2 in range(a1,174):
#		for a3 in range(a2,174):
#			if len(filter(lambda e: (e[1]==a2 or e[1]==a3), G.edges(nbunch=[a1])))>1 and len(filter(lambda e: (e[1]==a1 or e[1]==a3), G.edges(nbunch=[a2])))>1 and a1!=a2 and a2!=a3 and a3!=a1 and len(filter(lambda e: (e[1]==a1 or e[1]==a2), G.edges(nbunch=[a3])))>1:
#				print a1,a2,a3

print G.edges(nbunch=[124])
print G.edges(nbunch=[46])
print G.edges(nbunch=[107])

print nx.algorithms.distance_measures.diameter(G)
#print 50, ids[50]		
#print 60, ids[60]		
#print 152, ids[152]		
#print 173, ids[173]		
                    
#plt.axis('off')
#plt.savefig("weighted_graph.png") # save as png

#Para mostrarlo y usarlo
#plt.show() # display


